// pages/detail/detail.js
// 引入数据库操作辅助模块
const dbHelper = require('../../utils/dbHelper');

Page({

    /**
     * 页面的初始数据
     */
    data: {
        detailType: '', // 详情类型，可选值为 'request' (咨询申请) 或 'result' (测评结果)
        itemId: '', // 当前详情项的ID，可能是申请ID或结果ID
        loading: true, // 页面加载状态，true表示加载中
        requestDetail: null, // 咨询申请的详细信息对象
        resultDetail: null, // 测评结果的详细信息对象
        pageTitle: '详情', // 页面顶部导航栏的标题
        // 申请状态对应的文本描述
        statusText: {
            'pending': '待审批',
            'approved': '已通过',
            'rejected': '已拒绝',
            'completed': '已完成'
        },
        from: '', // 标记此详情页的来源页面，用于操作完成后的跳转逻辑
        showRejectDialog: false, // 控制是否显示驳回原因输入对话框
        rejectReason: '', // 用户输入的驳回原因文本
        userInfo: null, // 当前登录用户的信息对象
        isTeacher: false, // 标记当前用户是否为教师角色
        isStaff: false // 标记当前用户是否为工作人员角色
    },

    /**
     * 生命周期函数--监听页面加载
     * @param {object} options 页面启动参数，包含 id, type, from 等
     */
    onLoad(options) {
        // 解构获取页面启动参数中的 id, type 和 from
        const { id, type, from } = options;
        
        // 校验id参数是否存在，如果不存在则提示错误并返回上一页
        if (!id) {
            wx.showToast({
                title: '参数错误',
                icon: 'none',
                duration: 2000,
                // 提示显示完成后，延时2秒返回上一页
                success: () => {
                    setTimeout(() => {
                        wx.navigateBack();
                    }, 2000);
                }
            });
            return;
        }

        // 设置来源页面信息，如果options中没有from，则默认为空字符串
        this.setData({
            from: from || ''
        });

        // 从本地缓存中获取用户信息
        const userInfo = wx.getStorageSync('userInfo');
        // 更新页面数据，存储用户信息并判断用户角色
        this.setData({
            userInfo: userInfo,
            isTeacher: userInfo && userInfo.role === 'teacher',
            isStaff: userInfo && userInfo.role === 'staff'
        });

        // 根据传入的type参数，设置页面标题和详情类型
        let pageTitle = '详情'; // 默认页面标题
        let detailType = 'request'; // 默认详情类型为咨询申请
        
        // 如果options中传入了type参数，则使用该type
        if (type) {
            detailType = type;
        }
        
        // 根据detailType更新pageTitle
        if (detailType === 'request') {
            pageTitle = '咨询申请详情';
        } else if (detailType === 'result') {
            pageTitle = '测评结果详情';
        }

        // 更新页面数据，设置详情类型、条目ID和页面标题
        this.setData({
            detailType,
            itemId: id,
            pageTitle
        });

        // 调用方法加载详情数据
        this.loadDetailData();
    },

    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady() {
        // 页面初次渲染完成时执行的逻辑，目前为空
    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow() {
        // 页面显示时执行的逻辑，目前为空
    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {
        // 页面隐藏时执行的逻辑，目前为空
    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {
        // 页面卸载时执行的逻辑，目前为空
    },

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {
        // 用户下拉刷新时执行的逻辑，目前为空
    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {
        // 页面上拉触底时执行的逻辑，目前为空
    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {
        // 用户点击右上角分享按钮时执行的逻辑，目前为空
    },

    // 异步加载详情数据的主函数
    async loadDetailData() {
        // 设置加载状态为true，显示加载提示
        this.setData({
            loading: true
        });

        try {
            // 根据详情类型调用相应的加载函数
            if (this.data.detailType === 'request') {
                await this.loadRequestDetail(); // 加载咨询申请详情
            } else if (this.data.detailType === 'result') {
                await this.loadResultDetail(); // 加载测评结果详情
            }
        } catch (error) {
            // 捕获加载过程中的错误
            console.error('加载详情失败', error);
            // 显示错误提示
            wx.showToast({
                title: '加载失败，请重试',
                icon: 'none'
            });
        } finally {
            // 无论成功或失败，最终都设置加载状态为false
            this.setData({
                loading: false
            });
        }
    },

    // 异步加载咨询申请详情的具体实现
    async loadRequestDetail() {
        try {
            // 获取数据库引用
            const db = wx.cloud.database();
            console.log('正在加载申请ID:', this.data.itemId);
            
            // 根据itemId从'consultation_requests'集合中获取文档数据
            const result = await db.collection('consultation_requests').doc(this.data.itemId).get();
            
            // 判断查询结果是否存在且包含数据
            if (result && result.data) {
                const requestDetail = result.data;
                console.log('获取到申请详情:', requestDetail);
                
                // 格式化创建时间
                if (requestDetail.createTime) {
                    let createTime; // 声明用于存储Date对象的变量
                    // 判断createTime的类型，并转换为Date对象
                    if (typeof requestDetail.createTime === 'string') {
                        createTime = new Date(requestDetail.createTime);
                    } else if (requestDetail.createTime instanceof Date) {
                        createTime = requestDetail.createTime;
                    } else {
                        // 处理云函数返回的特殊时间对象或时间戳
                        createTime = new Date(requestDetail.createTime.getTime ? requestDetail.createTime.getTime() : requestDetail.createTime);
                    }
                    
                    // 提取年、月、日、时、分
                    const year = createTime.getFullYear();
                    const month = ('0' + (createTime.getMonth() + 1)).slice(-2); // 月份从0开始，需要+1，并补零
                    const day = ('0' + createTime.getDate()).slice(-2); // 补零
                    const hours = ('0' + createTime.getHours()).slice(-2); // 补零
                    const minutes = ('0' + createTime.getMinutes()).slice(-2); // 补零
                    
                    // 格式化为 'YYYY-MM-DD HH:mm' 字符串
                    requestDetail.createTimeFormatted = `${year}-${month}-${day} ${hours}:${minutes}`;
                }
                
                // 格式化预期咨询时间
                if (requestDetail.expectedDate) {
                    requestDetail.expectedTimeFormatted = requestDetail.expectedDate;
                    // 如果有具体时间段，则拼接
                    if (requestDetail.expectedTimeSlot) {
                        requestDetail.expectedTimeFormatted += ' ' + requestDetail.expectedTimeSlot;
                    }
                }
                
                // 更新页面数据，存储获取到的申请详情
                this.setData({
                    requestDetail
                });
                console.log('已更新申请详情到页面:', this.data.requestDetail);
            } else {
                // 如果未找到数据，则打印错误并抛出异常
                console.error('未找到申请数据');
                throw new Error('未找到申请数据');
            }
        } catch (error) {
            // 捕获获取申请详情过程中的错误
            console.error('获取申请详情失败', error);
            throw error; // 将错误继续向上抛出
        }
    },

    // 异步加载测评结果详情的具体实现
    async loadResultDetail() {
        try {
            // 获取数据库引用
            const db = wx.cloud.database();
            // 根据itemId从'consultation_records'集合中获取文档数据
            const result = await db.collection('consultation_records').doc(this.data.itemId).get();
            
            // 判断查询结果是否存在且包含数据
            if (result && result.data) {
                const resultDetail = result.data;
                
                // 格式化评测时间
                if (resultDetail.evaluationTime) {
                    let evaluationTime; // 声明用于存储Date对象的变量
                    // 判断evaluationTime的类型，并转换为Date对象
                    if (typeof resultDetail.evaluationTime === 'string') {
                        evaluationTime = new Date(resultDetail.evaluationTime);
                    } else if (resultDetail.evaluationTime instanceof Date) {
                        evaluationTime = resultDetail.evaluationTime;
                    } else {
                        // 处理云函数返回的特殊时间对象或时间戳
                        evaluationTime = new Date(resultDetail.evaluationTime.getTime ? resultDetail.evaluationTime.getTime() : resultDetail.evaluationTime);
                    }
                    
                    // 提取年、月、日、时、分
                    const year = evaluationTime.getFullYear();
                    const month = ('0' + (evaluationTime.getMonth() + 1)).slice(-2); // 月份从0开始，需要+1，并补零
                    const day = ('0' + evaluationTime.getDate()).slice(-2); // 补零
                    const hours = ('0' + evaluationTime.getHours()).slice(-2); // 补零
                    const minutes = ('0' + evaluationTime.getMinutes()).slice(-2); // 补零
                    
                    // 格式化为 'YYYY-MM-DD HH:mm' 字符串
                    resultDetail.evaluationTimeFormatted = `${year}-${month}-${day} ${hours}:${minutes}`;
                }
                
                // 更新页面数据，存储获取到的测评结果详情
                this.setData({
                    resultDetail
                });
            } else {
                // 如果未找到数据，则抛出异常
                throw new Error('未找到咨询记录数据');
            }
        } catch (error) {
            // 捕获获取测评结果详情过程中的错误
            console.error('获取咨询记录失败', error);
            throw error; // 将错误继续向上抛出
        }
    },

    // 审批通过咨询申请的函数
    approveRequest: async function() {
        // 权限校验：只有工作人员可以操作
        if (!this.data.isStaff) {
            wx.showToast({
                title: '只有工作人员可以处理申请',
                icon: 'none'
            });
            return;
        }

        // 显示确认对话框
        wx.showModal({
            title: '审批确认',
            content: '确定通过此申请？',
            // 用户点击确认后的回调
            success: async (res) => {
                if (res.confirm) {
                    // 显示处理中提示
                    wx.showLoading({
                        title: '处理中',
                        mask: true // 防止用户穿透点击
                    });

                    try {
                        const db = wx.cloud.database();
                        // 获取当前申请详情，确保studentName存在
                        const requestDetail = this.data.requestDetail || {};
                        
                        // 如果studentName不存在，则使用默认值，防止数据库写入undefined
                        const studentName = requestDetail.studentName || '未知学生';
                        
                        // 更新数据库中对应申请的状态等信息
                        await db.collection('consultation_requests').doc(this.data.itemId).update({
                            data: {
                                status: 'approved', // 将状态更新为已通过
                                staffId: this.data.userInfo.openId || this.data.userInfo._openid, // 记录处理人ID
                                studentName: studentName, // 确保存储学生姓名
                                updateTime: new Date() // 记录更新时间
                            }
                        });

                        wx.hideLoading(); // 隐藏处理中提示
                        // 显示操作成功提示
                        wx.showToast({
                            title: '已通过申请',
                            icon: 'success',
                            duration: 2000,
                            // 提示显示完成后，根据来源页面进行跳转或刷新
                            success: () => {
                                setTimeout(() => {
                                    if (this.data.from === 'pending') {
                                        wx.navigateBack(); // 如果来自待处理列表，则返回上一页
                                    } else {
                                        this.loadDetailData(); // 否则刷新当前详情页数据
                                    }
                                }, 2000);
                            }
                        });
                    } catch (error) {
                        // 捕获审批过程中的错误
                        console.error('审批申请失败', error);
                        wx.hideLoading(); // 隐藏处理中提示
                        // 显示操作失败提示
                        wx.showToast({
                            title: '操作失败，请重试',
                            icon: 'none'
                        });
                    }
                }
            }
        });
    },

    // 点击驳回申请按钮触发的函数
    rejectRequest: function() {
        // 权限校验：只有工作人员可以操作
        if (!this.data.isStaff) {
            wx.showToast({
                title: '只有工作人员可以处理申请',
                icon: 'none'
            });
            return;
        }

        // 显示驳回原因输入对话框
        this.setData({
            showRejectDialog: true
        });
    },

    // 提交驳回原因并执行驳回操作的函数
    submitReject: async function() {
        // 校验是否填写了驳回原因
        if (!this.data.rejectReason.trim()) {
            wx.showToast({
                title: '请填写驳回原因',
                icon: 'none'
            });
            return;
        }

        // 显示处理中提示
        wx.showLoading({
            title: '处理中',
            mask: true
        });

        try {
            const db = wx.cloud.database();
            // 获取当前申请详情，确保studentName存在
            const requestDetail = this.data.requestDetail || {};
            
            // 如果studentName不存在，则使用默认值
            const studentName = requestDetail.studentName || '未知学生';
            
            // 更新数据库中对应申请的状态和驳回原因等信息
            await db.collection('consultation_requests').doc(this.data.itemId).update({
                data: {
                    status: 'rejected', // 将状态更新为已驳回
                    staffId: this.data.userInfo.openId || this.data.userInfo._openid, // 记录处理人ID
                    rejectReason: this.data.rejectReason, // 记录驳回原因
                    studentName: studentName, // 确保存储学生姓名
                    updateTime: new Date() // 记录更新时间
                }
            });

            // 关闭驳回原因对话框并清空原因文本
            this.setData({
                showRejectDialog: false,
                rejectReason: ''
            });

            wx.hideLoading(); // 隐藏处理中提示
            // 显示操作成功提示
            wx.showToast({
                title: '已驳回申请',
                icon: 'success',
                duration: 2000,
                // 提示显示完成后，根据来源页面进行跳转或刷新
                success: () => {
                    setTimeout(() => {
                        if (this.data.from === 'pending') {
                            wx.navigateBack(); // 如果来自待处理列表，则返回上一页
                        } else {
                            this.loadDetailData(); // 否则刷新当前详情页数据
                        }
                    }, 2000);
                }
            });
        } catch (error) {
            // 捕获驳回过程中的错误
            console.error('驳回申请失败', error);
            wx.hideLoading(); // 隐藏处理中提示
            // 显示操作失败提示
            wx.showToast({
                title: '操作失败，请重试',
                icon: 'none'
            });
        }
    },

    // 取消驳回操作，关闭对话框
    cancelReject: function() {
        this.setData({
            showRejectDialog: false, // 隐藏对话框
            rejectReason: '' // 清空已输入的驳回原因
        });
    },

    // 监听驳回原因输入框的输入事件
    inputRejectReason: function(e) {
        // 将输入框的值同步到页面的rejectReason数据
        this.setData({
            rejectReason: e.detail.value
        });
    },
    
    // 点击"填写咨询结果"按钮触发的函数
    fillResult: function() {
        // 权限校验：教师或工作人员可以操作
        if (!this.data.isTeacher && !this.data.isStaff) {
            wx.showToast({
                title: '您没有权限执行此操作',
                icon: 'none'
            });
            return;
        }
        
        // 跳转到填写结果页面，并传递当前申请的ID (itemId)
        wx.navigateTo({
            url: `/pages/result/result?requestId=${this.data.itemId}`
        });
    }
})